继承和多态

1. 概述

继承和多态是面向对象编程（OOP）中的两个核心概念。继承允许一个类（子类）继承另一个类（父类）的属性和方法，从而实现代码的重用。多态则允许子类以不同的方式实现父类的方法，从而提供灵活性和扩展性。

2. 继承

2.1 什么是继承？

继承是一种机制，允许一个类（子类）继承另一个类（父类）的属性和方法。子类可以重用父类的代码，并且可以添加新的属性和方法，或者重写父类的方法。

2.2 继承的语法

在C#中，使用:符号来表示继承关系。例如：

public class Animal
{
    public string Name { get; set; }

    public void Eat()
    {
        Console.WriteLine($"{Name} is eating.");
    }
}

public class Dog : Animal
{
    public void Bark()
    {
        Console.WriteLine("Woof!");
    }
}

在这个例子中，Dog类继承了Animal类，因此Dog类可以使用Animal类的Name属性和Eat方法。

2.3 继承的实践练习

创建一个Vehicle类，并让Car类继承Vehicle类。Vehicle类有一个StartEngine方法，而Car类有一个Drive方法。

public class Vehicle
{
    public string Brand { get; set; }

    public void StartEngine()
    {
        Console.WriteLine($"The {Brand} engine is starting.");
    }
}

public class Car : Vehicle
{
    public void Drive()
    {
        Console.WriteLine($"The {Brand} car is driving.");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Car myCar = new Car();
        myCar.Brand = "Toyota";
        myCar.StartEngine();
        myCar.Drive();
    }
}

3. 多态

3.1 什么是多态？

多态是指同一个方法在不同的类中有不同的实现。多态性允许我们编写更灵活和可扩展的代码。

3.2 多态的实现

在C#中，多态通常通过方法重写（override）和接口实现来实现。

3.2.1 方法重写

方法重写允许子类提供一个与父类方法签名相同的方法实现。使用override关键字来重写父类的方法。

public class Animal
{
    public virtual void MakeSound()
    {
        Console.WriteLine("The animal makes a sound.");
    }
}

public class Dog : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("The dog barks.");
    }
}

public class Cat : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("The cat meows.");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        myDog.MakeSound(); // 输出: The dog barks.
        myCat.MakeSound(); // 输出: The cat meows.
    }
}

3.2.2 接口实现

接口定义了一组方法签名，类可以实现这些接口并提供具体的实现。

public interface IShape
{
    void Draw();
}

public class Circle : IShape
{
    public void Draw()
    {
        Console.WriteLine("Drawing a circle.");
    }
}

public class Rectangle : IShape
{
    public void Draw()
    {
        Console.WriteLine("Drawing a rectangle.");
    }
}

class Program
{
    static void Main(string[] args)
    {
        IShape myCircle = new Circle();
        IShape myRectangle = new Rectangle();

        myCircle.Draw(); // 输出: Drawing a circle.
        myRectangle.Draw(); // 输出: Drawing a rectangle.
    }
}

3.3 多态的实践练习

创建一个Shape类，并让Circle和Rectangle类继承Shape类。每个子类重写Draw方法以实现不同的绘制逻辑。

public class Shape
{
    public virtual void Draw()
    {
        Console.WriteLine("Drawing a shape.");
    }
}

public class Circle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a circle.");
    }
}

public class Rectangle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a rectangle.");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Shape myCircle = new Circle();
        Shape myRectangle = new Rectangle();

        myCircle.Draw(); // 输出: Drawing a circle.
        myRectangle.Draw(); // 输出: Drawing a rectangle.
    }
}

4. 总结

继承和多态是面向对象编程中的重要概念，它们提供了代码重用和灵活性的机制。通过继承，子类可以重用父类的属性和方法；通过多态，子类可以以不同的方式实现父类的方法。掌握这些概念将帮助你编写更高效、可维护和可扩展的代码。

5. 下一步

在掌握了继承和多态的基础知识后，你可以继续学习接口和抽象类，这些概念进一步扩展了继承和多态的应用场景。此外，你还可以探索泛型、委托和事件等高级主题，以进一步提升你的编程技能。